js_parser: visit the value an exports.replace entry discards as dead code - #38527

Problem

• Bun.Transpiler with exports: { replace: { getStaticProps: "x" } } (a plain replacement value) prints the replacement, but an import used only by the value it replaced survives trimUnusedImports, and scan() keeps reporting it (including import() records made inside that value):

  new Bun.Transpiler({ loader: "tsx", trimUnusedImports: true, exports: { replace: { getStaticProps: "x" } } })
    .transformSync(`import { serverHelper } from "./server-only";\nexport const getStaticProps = () => serverHelper();\n`);
  // import { serverHelper } from "./server-only";   <- should be gone, nothing left uses it
  // export const getStaticProps = "x";

• Same for export var / export let, export default <expr>, export default () => ... and export default function f() {}. eliminate: [...] and the inject form (replace: { x: ["__N_SSG", true] }) trim the import, so the three entry kinds disagree. Once Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 lands, helpers only the replaced value called would be kept too, for the same reason.
• Scope of what this changes in the output today: with the js / jsx loaders the import statement disappears and scan() stops listing it; with ts / tsx the binding is removed but the statement stays as a bare import "./server-only" and scan() still lists it, exactly what eliminate produces there today, because TypeScript import removal is keyed on ts_use_counts, which counts dead code too. Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 changes that scanner rule for files with exports entries; with it, both kinds drop the statement.
• There is no user report for this; it was found while working on Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352, which lists it as out of scope. It is the missing half of what exports.eliminate has done since the option was added, and it is what lets Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352's declaration removal apply to replaced exports as well.
• export default class X {} with a replacement value printed the class itself instead of the replacement.
• Cause of the first two: visit_decls (src/js_parser/visit/mod.rs, the is_control_flow_dead assignment next to the replace_exports lookup) and s_export_default (src/js_parser/visit/visit_stmt.rs) only set is_control_flow_dead for non-Replace entries before visiting the original value. replace_decl_and_possibly_remove / the mark_for_replace blocks then overwrite the value for Replace as well, so it was visited as live code for nothing and every symbol it referenced kept the use count recorded during that visit. The check dates from the commit that introduced the API (42414d5); s_function and s_class already mark the body dead for every entry kind.
• Cause of the third: the class branch of s_export_default wrote the replacement into data.value and then fell through to the class lowering, which writes the lowered class back into data.value.

Fix

• visit_decls: set is_control_flow_dead for any matching entry. The flag is restored right after the initializer is visited, as before, so the replacement value itself (visited in replace_decl_and_possibly_remove) and the other declarations of the same statement stay live.
• s_export_default: set the flag for any matching entry, and for a Replace entry restore it right after the value has been visited (discarded_value_visited!, used after the expression, function and class visits). The early if p.is_control_flow_dead returns and everything after them behave as before: Delete / Inject still return early, Replace still reaches the replacement, now with the old value's uses not counted.
• Class branch: the Replace arm pushes the replaced statement and returns, as the function branch already does, instead of falling through to the lowering. Needed here because the dead visit now empties the discarded class's method bodies, which would have been visible in the wrongly printed class. js_parser: apply exports.eliminate/replace to function and class declarations #33378 carries the same change to this arm.
• Why this is right: for every entry kind the visited value is discarded, so record_usage must not count its references; that is the only thing is_control_flow_dead changes for it (plus not registering import() / require() records and not running macros inside it, which eliminate already does). exports.eliminate has used this exact mechanism since the API was added, so Replace now goes through the same well exercised path. The dead_code_elimination gate is kept, like the other sites.
• Not changed on purpose:
  • export { name } clauses keep the local declaration in the output, so its initializer really is live; s_export_clause is untouched (js_parser: key exports.eliminate/replace on the exported name #33386 covers that form).
  • An inject entry for default (replace: { default: ["__N_SSG", true] }) still emits nothing when dead code elimination is on. That path is byte for byte the same before and after this change (the value was already visited dead and the early return already fired); js_parser: apply exports.eliminate/replace to function and class declarations #33378 fixes it.
  • With deadCodeElimination: false the import is still kept, as for the other sites.
• Verified with test/bundler/transpiler/transpiler.test.js (exports.replace > the value an entry discards is dead code): const / var / let / function declarations plus injected and eliminated entries side by side, seven export default shapes (expression, arrow, function, named class, anonymous class, a class whose extends clause uses the import, a class whose static field initializer uses it) each asserting the exact output and scan(), an import() inside the replaced value, the ts loader output described above (pinned next to eliminate's, so Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 updates both together), and two cases that must keep an import still used elsewhere (another statement, and a sibling declaration of the same export const). 13 of the 16 fail on main's parser (the three that pass are the export function, injected and eliminated rows, which document the behaviour the others are brought in line with), all pass with the fix.
• Also ran the rest of test/bundler/transpiler and test/js/bun/transpiler with the debug build; the only failures were jsx-production.test.ts cases hitting their 5 s timeout; a single one of those subprocesses takes 5.6 s in this debug build on its own, and they do not use the exports option.
• The tests use numeric replacement values: a string value's AST node is created in the thread-local AST store during option parsing and dangles once any synchronous parse resets that store (deterministic ASAN crash in the printer on main, independent of this change). That is reported separately; numbers and booleans are stored inline in ExprData and are not affected.

Relationship to the other open PRs in this area

• js_parser: apply exports.eliminate/replace to function and class declarations #33378 (function / class declarations, export default inject, uninitialized declarations): independent of this change, but the two overlap on the class Replace arm and both add a macro at the same spot in s_export_default; whichever lands second has a two-hunk rebase with no semantic interaction. js_parser: apply exports.eliminate/replace to function and class declarations #33378 landing first is the simpler order.
• Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 (treeShaking removes unused declarations, ts / tsx drop the emptied import statement): this PR is what makes that removal reach values that were replaced rather than eliminated; without this, Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 keeps the replaced value's helpers and imports alive. After Bun.Transpiler: make treeShaking remove unused declarations and their imports #38352 the ts assertion added here becomes the js output.
• js_parser: key exports.eliminate/replace on the exported name #33386 (export { name } clauses) and the string replacement value lifetime bug (reported separately) are disjoint from this change.

Background

• exports.replace / exports.eliminate (Bun.Transpiler options) become replace_exports, a map from export name to ReplaceableExport::{Delete, Replace(value), Inject { name, value }} (src/ast/runtime.rs). The visitor consults it when it reaches an exported declaration: Delete drops the declaration, Replace keeps it with value as its initializer, Inject drops it and emits export var <name> = value instead. In all three cases the original value never reaches the output.
• is_control_flow_dead is the parser flag for "the code being visited will not be emitted" (if (false) bodies and the like). While it is set, record_usage does not bump use_count_estimate and import() / require() do not create import records. The import scanner later removes import bindings whose use_count_estimate is 0; with trimUnusedImports an import statement left without bindings is dropped (js / jsx loaders) or kept as a bare side effect import (ts / tsx, because TypeScript's separate ts_use_counts still sees the reference).
• exports.eliminate already worked because the eliminated declaration was visited with this flag set; in addition an export whose whole statement disappears leaves an empty part, and append_part gives the uses recorded in an empty part back. A replaced export keeps its statement, so only the first mechanism can apply to it, which is what this change enables.
• s_export_default holds the S::ExportDefault payload through data; the Stmt pushed to the output shares that arena allocation, so assigning data.value before or after stmts.push(*stmt) both end up in the output. The class lowering (lower_class) returns a fresh statement list and the branch stores its class statement back into data.value, which is what undid the replacement.

source: import {a} from './a';  +  the export below          main                                   this PR
export const foo = () => a();          replace foo: 42      import { a } from "./a"; export const foo = 42;      export const foo = 42;
export var   foo = () => a();          replace foo: 42      import kept                                          export var foo = 42;
export function foo() { return a() }   replace foo: 42      export var foo = 42;                                 unchanged
export const foo = () => a();          inject  foo: [..]    export const __N_SSG = true;                         unchanged
export const foo = () => a();          eliminate foo        (empty)                                              unchanged
export default a();                    replace default: 42  import kept; export default 42;                      export default 42;
export default () => a();              replace default: 42  import kept                                          export default 42;
export default function P() {..a()..}  replace default: 42  import kept                                          export default 42;
export default class P { m(){a()} }    replace default: 42  class printed, import kept                           export default 42;
export default class { m(){a()} }      replace default: 42  class printed, import kept                           export default 42;
export default class P {}              inject default: [..] (empty)                                              unchanged (#33378)
scan() of the first line              replace foo: 42      imports: [{ path: "./a" }]                           imports: []
ts loader, first line                 replace foo: 42      import { a } from "./a"; export const foo = 42;      import "./a"; export const foo = 42;   (eliminate already prints import "./a")